home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / idlelib / run.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  12KB  |  375 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. import sys
  5. import os
  6. import linecache
  7. import time
  8. import socket
  9. import traceback
  10. import thread
  11. import threading
  12. import Queue
  13. import CallTips
  14. import AutoComplete
  15. import RemoteDebugger
  16. import RemoteObjectBrowser
  17. import StackViewer
  18. import rpc
  19. import __main__
  20. LOCALHOST = '127.0.0.1'
  21.  
  22. try:
  23.     import warnings
  24. except ImportError:
  25.     pass
  26.  
  27.  
  28. def idle_formatwarning_subproc(message, category, filename, lineno):
  29.     '''Format warnings the IDLE way'''
  30.     s = '\nWarning (from warnings module):\n'
  31.     s += '  File "%s", line %s\n' % (filename, lineno)
  32.     line = linecache.getline(filename, lineno).strip()
  33.     if line:
  34.         s += '    %s\n' % line
  35.     
  36.     s += '%s: %s\n' % (category.__name__, message)
  37.     return s
  38.  
  39. warnings.formatwarning = idle_formatwarning_subproc
  40. exit_now = False
  41. quitting = False
  42.  
  43. def main(del_exitfunc = False):
  44.     """Start the Python execution server in a subprocess
  45.  
  46.     In the Python subprocess, RPCServer is instantiated with handlerclass
  47.     MyHandler, which inherits register/unregister methods from RPCHandler via
  48.     the mix-in class SocketIO.
  49.  
  50.     When the RPCServer 'server' is instantiated, the TCPServer initialization
  51.     creates an instance of run.MyHandler and calls its handle() method.
  52.     handle() instantiates a run.Executive object, passing it a reference to the
  53.     MyHandler object.  That reference is saved as attribute rpchandler of the
  54.     Executive instance.  The Executive methods have access to the reference and
  55.     can pass it on to entities that they command
  56.     (e.g. RemoteDebugger.Debugger.start_debugger()).  The latter, in turn, can
  57.     call MyHandler(SocketIO) register/unregister methods via the reference to
  58.     register and unregister themselves.
  59.  
  60.     """
  61.     global no_exitfunc, exit_now
  62.     no_exitfunc = del_exitfunc
  63.     port = 8833
  64.     if sys.argv[1:]:
  65.         port = int(sys.argv[1])
  66.     
  67.     sys.argv[:] = [
  68.         '']
  69.     sockthread = threading.Thread(target = manage_socket, name = 'SockThread', args = ((LOCALHOST, port),))
  70.     sockthread.setDaemon(True)
  71.     sockthread.start()
  72.     while None:
  73.         
  74.         try:
  75.             if exit_now:
  76.                 
  77.                 try:
  78.                     exit()
  79.                 except KeyboardInterrupt:
  80.                     continue
  81.                 except:
  82.                     None<EXCEPTION MATCH>KeyboardInterrupt
  83.                 
  84.  
  85.             None<EXCEPTION MATCH>KeyboardInterrupt
  86.             
  87.             try:
  88.                 (seq, request) = rpc.request_queue.get(block = True, timeout = 0.05)
  89.             except Queue.Empty:
  90.                 continue
  91.  
  92.             (method, args, kwargs) = request
  93.             ret = method(*args, **kwargs)
  94.             rpc.response_queue.put((seq, ret))
  95.         continue
  96.         except KeyboardInterrupt:
  97.             if quitting:
  98.                 exit_now = True
  99.                 continue
  100.             continue
  101.             continue
  102.             except SystemExit:
  103.                 raise 
  104.                 continue
  105.                 (type, value, tb) = sys.exc_info()
  106.                 
  107.                 try:
  108.                     print_exception()
  109.                     rpc.response_queue.put((seq, None))
  110.                 continue
  111.                 traceback.print_exception(type, value, tb, file = sys.__stderr__)
  112.                 exit()
  113.  
  114.                 continue
  115.                 continue
  116.             
  117.             return None
  118.  
  119.  
  120.  
  121. def manage_socket(address):
  122.     global exit_now
  123.     for i in range(3):
  124.         time.sleep(i)
  125.         
  126.         try:
  127.             server = MyRPCServer(address, MyHandler)
  128.         continue
  129.         except socket.error:
  130.             err = None
  131.             print >>sys.__stderr__, 'IDLE Subprocess: socket error: ' + err[1] + ', retrying....'
  132.             continue
  133.         
  134.  
  135.     else:
  136.         print >>sys.__stderr__, 'IDLE Subprocess: Connection to IDLE GUI failed, exiting.'
  137.         exit_now = True
  138.         return None
  139.     server.handle_request()
  140.  
  141.  
  142. def show_socket_error(err, address):
  143.     import Tkinter as Tkinter
  144.     import tkMessageBox as tkMessageBox
  145.     root = Tkinter.Tk()
  146.     root.withdraw()
  147.     if err[0] == 61:
  148.         msg = "IDLE's subprocess can't connect to %s:%d.  This may be due to your personal firewall configuration.  It is safe to allow this internal connection because no data is visible on external ports." % address
  149.         tkMessageBox.showerror('IDLE Subprocess Error', msg, parent = root)
  150.     else:
  151.         tkMessageBox.showerror('IDLE Subprocess Error', 'Socket Error: %s' % err[1])
  152.     root.destroy()
  153.  
  154.  
  155. def print_exception():
  156.     import linecache
  157.     linecache.checkcache()
  158.     flush_stdout()
  159.     efile = sys.stderr
  160.     (typ, val, tb) = excinfo = sys.exc_info()
  161.     (sys.last_type, sys.last_value, sys.last_traceback) = excinfo
  162.     tbe = traceback.extract_tb(tb)
  163.     print >>efile, '\nTraceback (most recent call last):'
  164.     exclude = ('run.py', 'rpc.py', 'threading.py', 'Queue.py', 'RemoteDebugger.py', 'bdb.py')
  165.     cleanup_traceback(tbe, exclude)
  166.     traceback.print_list(tbe, file = efile)
  167.     lines = traceback.format_exception_only(typ, val)
  168.     for line in lines:
  169.         print >>efile, line,
  170.     
  171.  
  172.  
  173. def cleanup_traceback(tb, exclude):
  174.     '''Remove excluded traces from beginning/end of tb; get cached lines'''
  175.     orig_tb = tb[:]
  176.     while tb:
  177.         for rpcfile in exclude:
  178.             if tb[0][0].count(rpcfile):
  179.                 break
  180.                 continue
  181.         else:
  182.             break
  183.         del tb[0]
  184.     while tb:
  185.         for rpcfile in exclude:
  186.             if tb[-1][0].count(rpcfile):
  187.                 break
  188.                 continue
  189.         else:
  190.             break
  191.         del tb[-1]
  192.     if len(tb) == 0:
  193.         tb[:] = orig_tb[:]
  194.         print >>sys.stderr, '** IDLE Internal Exception: '
  195.     
  196.     rpchandler = rpc.objecttable['exec'].rpchandler
  197.     for i in range(len(tb)):
  198.         (fn, ln, nm, line) = tb[i]
  199.         if nm == '?':
  200.             nm = '-toplevel-'
  201.         
  202.         if not line and fn.startswith('<pyshell#'):
  203.             line = rpchandler.remotecall('linecache', 'getline', (fn, ln), { })
  204.         
  205.         tb[i] = (fn, ln, nm, line)
  206.     
  207.  
  208.  
  209. def flush_stdout():
  210.     
  211.     try:
  212.         if sys.stdout.softspace:
  213.             sys.stdout.softspace = 0
  214.             sys.stdout.write('\n')
  215.     except (AttributeError, EOFError):
  216.         pass
  217.  
  218.  
  219.  
  220. def exit():
  221.     """Exit subprocess, possibly after first deleting sys.exitfunc
  222.  
  223.     If config-main.cfg/.def 'General' 'delete-exitfunc' is True, then any
  224.     sys.exitfunc will be removed before exiting.  (VPython support)
  225.  
  226.     """
  227.     if no_exitfunc:
  228.         
  229.         try:
  230.             del sys.exitfunc
  231.         except AttributeError:
  232.             pass
  233.         except:
  234.             None<EXCEPTION MATCH>AttributeError
  235.         
  236.  
  237.     None<EXCEPTION MATCH>AttributeError
  238.     sys.exit(0)
  239.  
  240.  
  241. class MyRPCServer(rpc.RPCServer):
  242.     
  243.     def handle_error(self, request, client_address):
  244.         '''Override RPCServer method for IDLE
  245.  
  246.         Interrupt the MainThread and exit server if link is dropped.
  247.  
  248.         '''
  249.         global exit_now, quitting
  250.         
  251.         try:
  252.             raise 
  253.         except SystemExit:
  254.             raise 
  255.         except EOFError:
  256.             exit_now = True
  257.             thread.interrupt_main()
  258.         except:
  259.             erf = sys.__stderr__
  260.             print >>erf, '\n' + '-' * 40
  261.             print >>erf, 'Unhandled server exception!'
  262.             print >>erf, 'Thread: %s' % threading.currentThread().getName()
  263.             print >>erf, 'Client Address: ', client_address
  264.             print >>erf, 'Request: ', repr(request)
  265.             traceback.print_exc(file = erf)
  266.             print >>erf, '\n*** Unrecoverable, server exiting!'
  267.             print >>erf, '-' * 40
  268.             quitting = True
  269.             thread.interrupt_main()
  270.  
  271.  
  272.  
  273.  
  274. class MyHandler(rpc.RPCHandler):
  275.     
  276.     def handle(self):
  277.         '''Override base method'''
  278.         executive = Executive(self)
  279.         self.register('exec', executive)
  280.         sys.stdin = self.console = self.get_remote_proxy('stdin')
  281.         sys.stdout = self.get_remote_proxy('stdout')
  282.         sys.stderr = self.get_remote_proxy('stderr')
  283.         import IOBinding as IOBinding
  284.         sys.stdin.encoding = sys.stdout.encoding = sys.stderr.encoding = IOBinding.encoding
  285.         self.interp = self.get_remote_proxy('interp')
  286.         rpc.RPCHandler.getresponse(self, myseq = None, wait = 0.05)
  287.  
  288.     
  289.     def exithook(self):
  290.         '''override SocketIO method - wait for MainThread to shut us down'''
  291.         time.sleep(10)
  292.  
  293.     
  294.     def EOFhook(self):
  295.         '''Override SocketIO method - terminate wait on callback and exit thread'''
  296.         global quitting
  297.         quitting = True
  298.         thread.interrupt_main()
  299.  
  300.     
  301.     def decode_interrupthook(self):
  302.         '''interrupt awakened thread'''
  303.         global quitting
  304.         quitting = True
  305.         thread.interrupt_main()
  306.  
  307.  
  308.  
  309. class Executive(object):
  310.     
  311.     def __init__(self, rpchandler):
  312.         self.rpchandler = rpchandler
  313.         self.locals = __main__.__dict__
  314.         self.calltip = CallTips.CallTips()
  315.         self.autocomplete = AutoComplete.AutoComplete()
  316.  
  317.     
  318.     def runcode(self, code):
  319.         
  320.         try:
  321.             self.usr_exc_info = None
  322.             exec code in self.locals
  323.         except:
  324.             self.usr_exc_info = sys.exc_info()
  325.             if quitting:
  326.                 exit()
  327.             
  328.             print_exception()
  329.             jit = self.rpchandler.console.getvar('<<toggle-jit-stack-viewer>>')
  330.             if jit:
  331.                 self.rpchandler.interp.open_remote_stack_viewer()
  332.             
  333.  
  334.         flush_stdout()
  335.  
  336.     
  337.     def interrupt_the_server(self):
  338.         thread.interrupt_main()
  339.  
  340.     
  341.     def start_the_debugger(self, gui_adap_oid):
  342.         return RemoteDebugger.start_debugger(self.rpchandler, gui_adap_oid)
  343.  
  344.     
  345.     def stop_the_debugger(self, idb_adap_oid):
  346.         '''Unregister the Idb Adapter.  Link objects and Idb then subject to GC'''
  347.         self.rpchandler.unregister(idb_adap_oid)
  348.  
  349.     
  350.     def get_the_calltip(self, name):
  351.         return self.calltip.fetch_tip(name)
  352.  
  353.     
  354.     def get_the_completion_list(self, what, mode):
  355.         return self.autocomplete.fetch_completions(what, mode)
  356.  
  357.     
  358.     def stackviewer(self, flist_oid = None):
  359.         if self.usr_exc_info:
  360.             (typ, val, tb) = self.usr_exc_info
  361.         else:
  362.             return None
  363.         flist = None
  364.         if flist_oid is not None:
  365.             flist = self.rpchandler.get_remote_proxy(flist_oid)
  366.         
  367.         while tb and tb.tb_frame.f_globals['__name__'] in ('rpc', 'run'):
  368.             tb = tb.tb_next
  369.         sys.last_type = typ
  370.         sys.last_value = val
  371.         item = StackViewer.StackTreeItem(flist, tb)
  372.         return RemoteObjectBrowser.remote_object_tree_item(item)
  373.  
  374.  
  375.